/*
 * FreeRTOS Kernel V10.4.6
 * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.    All Rights Reserved.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * https://www.FreeRTOS.org
 * https://github.com/FreeRTOS
 *
 */


#ifndef TIMERS_H
#define TIMERS_H

#ifndef INC_FREERTOS_H
        #error "include FreeRTOS.h must appear in source files before include timers.h"
#endif

/*lint -save -e537 This headers are only multiply included if the application code
 * happens to also be including task.h. */
#include "task.h"
/*lint -restore */

/* *INDENT-OFF* */
#ifdef __cplusplus
        extern "C" {
#endif
/* *INDENT-ON* */

/*-----------------------------------------------------------
* MACROS AND DEFINITIONS
*----------------------------------------------------------*/

/* IDs for commands that can be sent/received on the timer queue.    These are to
 * be used solely through the macros that make up the public software timer API,
 * as defined below.    The commands that are sent from interrupts must use the
 * highest numbers as tmrFIRST_FROM_ISR_COMMAND is used to determine if the task
 * or interrupt version of the queue send function should be used. */
#define tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR        ( ( BaseType_t ) -2 )
#define tmrCOMMAND_EXECUTE_CALLBACK                         ( ( BaseType_t ) -1 )
#define tmrCOMMAND_START_DONT_TRACE                         ( ( BaseType_t ) 0 )
#define tmrCOMMAND_START                                                ( ( BaseType_t ) 1 )
#define tmrCOMMAND_RESET                                                ( ( BaseType_t ) 2 )
#define tmrCOMMAND_STOP                                                 ( ( BaseType_t ) 3 )
#define tmrCOMMAND_CHANGE_PERIOD                                ( ( BaseType_t ) 4 )
#define tmrCOMMAND_DELETE                                             ( ( BaseType_t ) 5 )

#define tmrFIRST_FROM_ISR_COMMAND                             ( ( BaseType_t ) 6 )
#define tmrCOMMAND_START_FROM_ISR                             ( ( BaseType_t ) 6 )
#define tmrCOMMAND_RESET_FROM_ISR                             ( ( BaseType_t ) 7 )
#define tmrCOMMAND_STOP_FROM_ISR                                ( ( BaseType_t ) 8 )
#define tmrCOMMAND_CHANGE_PERIOD_FROM_ISR             ( ( BaseType_t ) 9 )


/**
 * Type by which software timers are referenced.    For example, a call to
 * xTimerCreate() returns an TimerHandle_t variable that can then be used to
 * reference the subject timer in calls to other software timer API functions
 * (for example, xTimerStart(), xTimerReset(), etc.).
 */
struct tmrTimerControl; /* The old naming convention is used to prevent breaking kernel aware debuggers. */
typedef struct tmrTimerControl * TimerHandle_t;

/*
 * Defines the prototype to which timer callback functions must conform.
 */
typedef void (* TimerCallbackFunction_t)( TimerHandle_t xTimer );

/*
 * Defines the prototype to which functions used with the
 * xTimerPendFunctionCallFromISR() function must conform.
 */
typedef void (* PendedFunction_t)( void *,
                                                                     uint32_t );

/**
 * TimerHandle_t xTimerCreate(    const char * const pcTimerName,
 *                                                            TickType_t xTimerPeriodInTicks,
 *                                                            UBaseType_t uxAutoReload,
 *                                                            void * pvTimerID,
 *                                                            TimerCallbackFunction_t pxCallbackFunction );
 *
 * Creates a new software timer instance, and returns a handle by which the
 * created software timer can be referenced.
 *
 * Internally, within the FreeRTOS implementation, software timers use a block
 * of memory, in which the timer data structure is stored.    If a software timer
 * is created using xTimerCreate() then the required memory is automatically
 * dynamically allocated inside the xTimerCreate() function.    (see
 * https://www.FreeRTOS.org/a00111.html).    If a software timer is created using
 * xTimerCreateStatic() then the application writer must provide the memory that
 * will get used by the software timer.    xTimerCreateStatic() therefore allows a
 * software timer to be created without using any dynamic memory allocation.
 *
 * Timers are created in the dormant state.    The xTimerStart(), xTimerReset(),
 * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
 * xTimerChangePeriodFromISR() API functions can all be used to transition a
 * timer into the active state.
 *
 * @param pcTimerName A text name that is assigned to the timer.    This is done
 * purely to assist debugging.    The kernel itself only ever references a timer
 * by its handle, and never by its name.
 *
 * @param xTimerPeriodInTicks The timer period.    The time is defined in tick
 * periods so the constant portTICK_PERIOD_MS can be used to convert a time that
 * has been specified in milliseconds.    For example, if the timer must expire
 * after 100 ticks, then xTimerPeriodInTicks should be set to 100.
 * Alternatively, if the timer must expire after 500ms, then xPeriod can be set
 * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or
 * equal to 1000.    Time timer period must be greater than 0.
 *
 * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
 * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.
 * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
 * enter the dormant state after it expires.
 *
 * @param pvTimerID An identifier that is assigned to the timer being created.
 * Typically this would be used in the timer callback function to identify which
 * timer expired when the same callback function is assigned to more than one
 * timer.
 *
 * @param pxCallbackFunction The function to call when the timer expires.
 * Callback functions must have the prototype defined by TimerCallbackFunction_t,
 * which is "void vCallbackFunction( TimerHandle_t xTimer );".
 *
 * @return If the timer is successfully created then a handle to the newly
 * created timer is returned.    If the timer cannot be created because there is
 * insufficient FreeRTOS heap remaining to allocate the timer
 * structures then NULL is returned.
 *
 * Example usage:
 * @verbatim
 * #define NUM_TIMERS 5
 *
 * // An array to hold handles to the created timers.
 * TimerHandle_t xTimers[ NUM_TIMERS ];
 *
 * // An array to hold a count of the number of times each timer expires.
 * int32_t lExpireCounters[ NUM_TIMERS ] = { 0 };
 *
 * // Define a callback function that will be used by multiple timer instances.
 * // The callback function does nothing but count the number of times the
 * // associated timer expires, and stop the timer once the timer has expired
 * // 10 times.
 * void vTimerCallback( TimerHandle_t pxTimer )
 * {
 * int32_t lArrayIndex;
 * const int32_t xMaxExpiryCountBeforeStopping = 10;
 *
 *         // Optionally do something if the pxTimer parameter is NULL.
 *         configASSERT( pxTimer );
 *
 *         // Which timer expired?
 *         lArrayIndex = ( int32_t ) pvTimerGetTimerID( pxTimer );
 *
 *         // Increment the number of times that pxTimer has expired.
 *         lExpireCounters[ lArrayIndex ] += 1;
 *
 *         // If the timer has expired 10 times then stop it from running.
 *         if( lExpireCounters[ lArrayIndex ] == xMaxExpiryCountBeforeStopping )
 *         {
 *                 // Do not use a block time if calling a timer API function from a
 *                 // timer callback function, as doing so could cause a deadlock!
 *                 xTimerStop( pxTimer, 0 );
 *         }
 * }
 *
 * void main( void )
 * {
 * int32_t x;
 *
 *         // Create then start some timers.    Starting the timers before the scheduler
 *         // has been started means the timers will start running immediately that
 *         // the scheduler starts.
 *         for( x = 0; x < NUM_TIMERS; x++ )
 *         {
 *                 xTimers[ x ] = xTimerCreate(        "Timer",             // Just a text name, not used by the kernel.
 *                                                                                 ( 100 * x ),     // The timer period in ticks.
 *                                                                                 pdTRUE,                // The timers will auto-reload themselves when they expire.
 *                                                                                 ( void * ) x,    // Assign each timer a unique id equal to its array index.
 *                                                                                 vTimerCallback // Each timer calls the same callback when it expires.
 *                                                                         );
 *
 *                 if( xTimers[ x ] == NULL )
 *                 {
 *                         // The timer was not created.
 *                 }
 *                 else
 *                 {
 *                         // Start the timer.    No block time is specified, and even if one was
 *                         // it would be ignored because the scheduler has not yet been
 *                         // started.
 *                         if( xTimerStart( xTimers[ x ], 0 ) != pdPASS )
 *                         {
 *                                 // The timer could not be set into the Active state.
 *                         }
 *                 }
 *         }
 *
 *         // ...
 *         // Create tasks here.
 *         // ...
 *
 *         // Starting the scheduler will start the timers running as they have already
 *         // been set into the active state.
 *         vTaskStartScheduler();
 *
 *         // Should not reach here.
 *         for( ;; );
 * }
 * @endverbatim
 */
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
        TimerHandle_t xTimerCreate( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                                                const TickType_t xTimerPeriodInTicks,
                                                                const UBaseType_t uxAutoReload,
                                                                void * const pvTimerID,
                                                                TimerCallbackFunction_t pxCallbackFunction ) PRIVILEGED_FUNCTION;
#endif

/**
 * TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
 *                                                                    TickType_t xTimerPeriodInTicks,
 *                                                                    UBaseType_t uxAutoReload,
 *                                                                    void * pvTimerID,
 *                                                                    TimerCallbackFunction_t pxCallbackFunction,
 *                                                                    StaticTimer_t *pxTimerBuffer );
 *
 * Creates a new software timer instance, and returns a handle by which the
 * created software timer can be referenced.
 *
 * Internally, within the FreeRTOS implementation, software timers use a block
 * of memory, in which the timer data structure is stored.    If a software timer
 * is created using xTimerCreate() then the required memory is automatically
 * dynamically allocated inside the xTimerCreate() function.    (see
 * https://www.FreeRTOS.org/a00111.html).    If a software timer is created using
 * xTimerCreateStatic() then the application writer must provide the memory that
 * will get used by the software timer.    xTimerCreateStatic() therefore allows a
 * software timer to be created without using any dynamic memory allocation.
 *
 * Timers are created in the dormant state.    The xTimerStart(), xTimerReset(),
 * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
 * xTimerChangePeriodFromISR() API functions can all be used to transition a
 * timer into the active state.
 *
 * @param pcTimerName A text name that is assigned to the timer.    This is done
 * purely to assist debugging.    The kernel itself only ever references a timer
 * by its handle, and never by its name.
 *
 * @param xTimerPeriodInTicks The timer period.    The time is defined in tick
 * periods so the constant portTICK_PERIOD_MS can be used to convert a time that
 * has been specified in milliseconds.    For example, if the timer must expire
 * after 100 ticks, then xTimerPeriodInTicks should be set to 100.
 * Alternatively, if the timer must expire after 500ms, then xPeriod can be set
 * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or
 * equal to 1000.    The timer period must be greater than 0.
 *
 * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
 * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.
 * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
 * enter the dormant state after it expires.
 *
 * @param pvTimerID An identifier that is assigned to the timer being created.
 * Typically this would be used in the timer callback function to identify which
 * timer expired when the same callback function is assigned to more than one
 * timer.
 *
 * @param pxCallbackFunction The function to call when the timer expires.
 * Callback functions must have the prototype defined by TimerCallbackFunction_t,
 * which is "void vCallbackFunction( TimerHandle_t xTimer );".
 *
 * @param pxTimerBuffer Must point to a variable of type StaticTimer_t, which
 * will be then be used to hold the software timer's data structures, removing
 * the need for the memory to be allocated dynamically.
 *
 * @return If the timer is created then a handle to the created timer is
 * returned.    If pxTimerBuffer was NULL then NULL is returned.
 *
 * Example usage:
 * @verbatim
 *
 * // The buffer used to hold the software timer's data structure.
 * static StaticTimer_t xTimerBuffer;
 *
 * // A variable that will be incremented by the software timer's callback
 * // function.
 * UBaseType_t uxVariableToIncrement = 0;
 *
 * // A software timer callback function that increments a variable passed to
 * // it when the software timer was created.    After the 5th increment the
 * // callback function stops the software timer.
 * static void prvTimerCallback( TimerHandle_t xExpiredTimer )
 * {
 * UBaseType_t *puxVariableToIncrement;
 * BaseType_t xReturned;
 *
 *         // Obtain the address of the variable to increment from the timer ID.
 *         puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID( xExpiredTimer );
 *
 *         // Increment the variable to show the timer callback has executed.
 *         ( *puxVariableToIncrement )++;
 *
 *         // If this callback has executed the required number of times, stop the
 *         // timer.
 *         if( *puxVariableToIncrement == 5 )
 *         {
 *                 // This is called from a timer callback so must not block.
 *                 xTimerStop( xExpiredTimer, staticDONT_BLOCK );
 *         }
 * }
 *
 *
 * void main( void )
 * {
 *         // Create the software time.    xTimerCreateStatic() has an extra parameter
 *         // than the normal xTimerCreate() API function.    The parameter is a pointer
 *         // to the StaticTimer_t structure that will hold the software timer
 *         // structure.    If the parameter is passed as NULL then the structure will be
 *         // allocated dynamically, just as if xTimerCreate() had been called.
 *         xTimer = xTimerCreateStatic( "T1",                         // Text name for the task.    Helps debugging only.    Not used by FreeRTOS.
 *                                                                    xTimerPeriod,         // The period of the timer in ticks.
 *                                                                    pdTRUE,                     // This is an auto-reload timer.
 *                                                                    ( void * ) &uxVariableToIncrement,        // A variable incremented by the software timer's callback function
 *                                                                    prvTimerCallback, // The function to execute when the timer expires.
 *                                                                    &xTimerBuffer );    // The buffer that will hold the software timer structure.
 *
 *         // The scheduler has not started yet so a block time is not used.
 *         xReturned = xTimerStart( xTimer, 0 );
 *
 *         // ...
 *         // Create tasks here.
 *         // ...
 *
 *         // Starting the scheduler will start the timers running as they have already
 *         // been set into the active state.
 *         vTaskStartScheduler();
 *
 *         // Should not reach here.
 *         for( ;; );
 * }
 * @endverbatim
 */
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
        TimerHandle_t xTimerCreateStatic( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                                                            const TickType_t xTimerPeriodInTicks,
                                                                            const UBaseType_t uxAutoReload,
                                                                            void * const pvTimerID,
                                                                            TimerCallbackFunction_t pxCallbackFunction,
                                                                            StaticTimer_t * pxTimerBuffer ) PRIVILEGED_FUNCTION;
#endif /* configSUPPORT_STATIC_ALLOCATION */

/**
 * void *pvTimerGetTimerID( TimerHandle_t xTimer );
 *
 * Returns the ID assigned to the timer.
 *
 * IDs are assigned to timers using the pvTimerID parameter of the call to
 * xTimerCreated() that was used to create the timer, and by calling the
 * vTimerSetTimerID() API function.
 *
 * If the same callback function is assigned to multiple timers then the timer
 * ID can be used as time specific (timer local) storage.
 *
 * @param xTimer The timer being queried.
 *
 * @return The ID assigned to the timer being queried.
 *
 * Example usage:
 *
 * See the xTimerCreate() API function example usage scenario.
 */
void * pvTimerGetTimerID( const TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

/**
 * void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );
 *
 * Sets the ID assigned to the timer.
 *
 * IDs are assigned to timers using the pvTimerID parameter of the call to
 * xTimerCreated() that was used to create the timer.
 *
 * If the same callback function is assigned to multiple timers then the timer
 * ID can be used as time specific (timer local) storage.
 *
 * @param xTimer The timer being updated.
 *
 * @param pvNewID The ID to assign to the timer.
 *
 * Example usage:
 *
 * See the xTimerCreate() API function example usage scenario.
 */
void vTimerSetTimerID( TimerHandle_t xTimer,
                                             void * pvNewID ) PRIVILEGED_FUNCTION;

/**
 * BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer );
 *
 * Queries a timer to see if it is active or dormant.
 *
 * A timer will be dormant if:
 *         1) It has been created but not started, or
 *         2) It is an expired one-shot timer that has not been restarted.
 *
 * Timers are created in the dormant state.    The xTimerStart(), xTimerReset(),
 * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
 * xTimerChangePeriodFromISR() API functions can all be used to transition a timer into the
 * active state.
 *
 * @param xTimer The timer being queried.
 *
 * @return pdFALSE will be returned if the timer is dormant.    A value other than
 * pdFALSE will be returned if the timer is active.
 *
 * Example usage:
 * @verbatim
 * // This function assumes xTimer has already been created.
 * void vAFunction( TimerHandle_t xTimer )
 * {
 *         if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"
 *         {
 *                 // xTimer is active, do something.
 *         }
 *         else
 *         {
 *                 // xTimer is not active, do something else.
 *         }
 * }
 * @endverbatim
 */
BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

/**
 * TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
 *
 * Simply returns the handle of the timer service/daemon task.    It it not valid
 * to call xTimerGetTimerDaemonTaskHandle() before the scheduler has been started.
 */
TaskHandle_t xTimerGetTimerDaemonTaskHandle( void ) PRIVILEGED_FUNCTION;

/**
 * BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );
 *
 * Timer functionality is provided by a timer service/daemon task.    Many of the
 * public FreeRTOS timer API functions send commands to the timer service task
 * through a queue called the timer command queue.    The timer command queue is
 * private to the kernel itself and is not directly accessible to application
 * code.    The length of the timer command queue is set by the
 * configTIMER_QUEUE_LENGTH configuration constant.
 *
 * xTimerStart() starts a timer that was previously created using the
 * xTimerCreate() API function.    If the timer had already been started and was
 * already in the active state, then xTimerStart() has equivalent functionality
 * to the xTimerReset() API function.
 *
 * Starting a timer ensures the timer is in the active state.    If the timer
 * is not stopped, deleted, or reset in the mean time, the callback function
 * associated with the timer will get called 'n' ticks after xTimerStart() was
 * called, where 'n' is the timers defined period.
 *
 * It is valid to call xTimerStart() before the scheduler has been started, but
 * when this is done the timer will not actually start until the scheduler is
 * started, and the timers expiry time will be relative to when the scheduler is
 * started, not relative to when xTimerStart() was called.
 *
 * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStart()
 * to be available.
 *
 * @param xTimer The handle of the timer being started/restarted.
 *
 * @param xTicksToWait Specifies the time, in ticks, that the calling task should
 * be held in the Blocked state to wait for the start command to be successfully
 * sent to the timer command queue, should the queue already be full when
 * xTimerStart() was called.    xTicksToWait is ignored if xTimerStart() is called
 * before the scheduler is started.
 *
 * @return pdFAIL will be returned if the start command could not be sent to
 * the timer command queue even after xTicksToWait ticks had passed.    pdPASS will
 * be returned if the command was successfully sent to the timer command queue.
 * When the command is actually processed will depend on the priority of the
 * timer service/daemon task relative to other tasks in the system, although the
 * timers expiry time is relative to when xTimerStart() is actually called.    The
 * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
 * configuration constant.
 *
 * Example usage:
 *
 * See the xTimerCreate() API function example usage scenario.
 *
 */
#define xTimerStart( xTimer, xTicksToWait ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) )

/**
 * BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xTicksToWait );
 *
 * Timer functionality is provided by a timer service/daemon task.    Many of the
 * public FreeRTOS timer API functions send commands to the timer service task
 * through a queue called the timer command queue.    The timer command queue is
 * private to the kernel itself and is not directly accessible to application
 * code.    The length of the timer command queue is set by the
 * configTIMER_QUEUE_LENGTH configuration constant.
 *
 * xTimerStop() stops a timer that was previously started using either of the
 * The xTimerStart(), xTimerReset(), xTimerStartFromISR(), xTimerResetFromISR(),
 * xTimerChangePeriod() or xTimerChangePeriodFromISR() API functions.
 *
 * Stopping a timer ensures the timer is not in the active state.
 *
 * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStop()
 * to be available.
 *
 * @param xTimer The handle of the timer being stopped.
 *
 * @param xTicksToWait Specifies the time, in ticks, that the calling task should
 * be held in the Blocked state to wait for the stop command to be successfully
 * sent to the timer command queue, should the queue already be full when
 * xTimerStop() was called.    xTicksToWait is ignored if xTimerStop() is called
 * before the scheduler is started.
 *
 * @return pdFAIL will be returned if the stop command could not be sent to
 * the timer command queue even after xTicksToWait ticks had passed.    pdPASS will
 * be returned if the command was successfully sent to the timer command queue.
 * When the command is actually processed will depend on the priority of the
 * timer service/daemon task relative to other tasks in the system.    The timer
 * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
 * configuration constant.
 *
 * Example usage:
 *
 * See the xTimerCreate() API function example usage scenario.
 *
 */
#define xTimerStop( xTimer, xTicksToWait ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0U, NULL, ( xTicksToWait ) )

/**
 * BaseType_t xTimerChangePeriod(     TimerHandle_t xTimer,
 *                                                                    TickType_t xNewPeriod,
 *                                                                    TickType_t xTicksToWait );
 *
 * Timer functionality is provided by a timer service/daemon task.    Many of the
 * public FreeRTOS timer API functions send commands to the timer service task
 * through a queue called the timer command queue.    The timer command queue is
 * private to the kernel itself and is not directly accessible to application
 * code.    The length of the timer command queue is set by the
 * configTIMER_QUEUE_LENGTH configuration constant.
 *
 * xTimerChangePeriod() changes the period of a timer that was previously
 * created using the xTimerCreate() API function.
 *
 * xTimerChangePeriod() can be called to change the period of an active or
 * dormant state timer.
 *
 * The configUSE_TIMERS configuration constant must be set to 1 for
 * xTimerChangePeriod() to be available.
 *
 * @param xTimer The handle of the timer that is having its period changed.
 *
 * @param xNewPeriod The new period for xTimer. Timer periods are specified in
 * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a time
 * that has been specified in milliseconds.    For example, if the timer must
 * expire after 100 ticks, then xNewPeriod should be set to 100.    Alternatively,
 * if the timer must expire after 500ms, then xNewPeriod can be set to
 * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than
 * or equal to 1000.
 *
 * @param xTicksToWait Specifies the time, in ticks, that the calling task should
 * be held in the Blocked state to wait for the change period command to be
 * successfully sent to the timer command queue, should the queue already be
 * full when xTimerChangePeriod() was called.    xTicksToWait is ignored if
 * xTimerChangePeriod() is called before the scheduler is started.
 *
 * @return pdFAIL will be returned if the change period command could not be
 * sent to the timer command queue even after xTicksToWait ticks had passed.
 * pdPASS will be returned if the command was successfully sent to the timer
 * command queue.    When the command is actually processed will depend on the
 * priority of the timer service/daemon task relative to other tasks in the
 * system.    The timer service/daemon task priority is set by the
 * configTIMER_TASK_PRIORITY configuration constant.
 *
 * Example usage:
 * @verbatim
 * // This function assumes xTimer has already been created.    If the timer
 * // referenced by xTimer is already active when it is called, then the timer
 * // is deleted.    If the timer referenced by xTimer is not active when it is
 * // called, then the period of the timer is set to 500ms and the timer is
 * // started.
 * void vAFunction( TimerHandle_t xTimer )
 * {
 *         if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"
 *         {
 *                 // xTimer is already active - delete it.
 *                 xTimerDelete( xTimer );
 *         }
 *         else
 *         {
 *                 // xTimer is not active, change its period to 500ms.    This will also
 *                 // cause the timer to start.    Block for a maximum of 100 ticks if the
 *                 // change period command cannot immediately be sent to the timer
 *                 // command queue.
 *                 if( xTimerChangePeriod( xTimer, 500 / portTICK_PERIOD_MS, 100 ) == pdPASS )
 *                 {
 *                         // The command was successfully sent.
 *                 }
 *                 else
 *                 {
 *                         // The command could not be sent, even after waiting for 100 ticks
 *                         // to pass.    Take appropriate action here.
 *                 }
 *         }
 * }
 * @endverbatim
 */
#define xTimerChangePeriod( xTimer, xNewPeriod, xTicksToWait ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), NULL, ( xTicksToWait ) )

/**
 * BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xTicksToWait );
 *
 * Timer functionality is provided by a timer service/daemon task.    Many of the
 * public FreeRTOS timer API functions send commands to the timer service task
 * through a queue called the timer command queue.    The timer command queue is
 * private to the kernel itself and is not directly accessible to application
 * code.    The length of the timer command queue is set by the
 * configTIMER_QUEUE_LENGTH configuration constant.
 *
 * xTimerDelete() deletes a timer that was previously created using the
 * xTimerCreate() API function.
 *
 * The configUSE_TIMERS configuration constant must be set to 1 for
 * xTimerDelete() to be available.
 *
 * @param xTimer The handle of the timer being deleted.
 *
 * @param xTicksToWait Specifies the time, in ticks, that the calling task should
 * be held in the Blocked state to wait for the delete command to be
 * successfully sent to the timer command queue, should the queue already be
 * full when xTimerDelete() was called.    xTicksToWait is ignored if xTimerDelete()
 * is called before the scheduler is started.
 *
 * @return pdFAIL will be returned if the delete command could not be sent to
 * the timer command queue even after xTicksToWait ticks had passed.    pdPASS will
 * be returned if the command was successfully sent to the timer command queue.
 * When the command is actually processed will depend on the priority of the
 * timer service/daemon task relative to other tasks in the system.    The timer
 * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
 * configuration constant.
 *
 * Example usage:
 *
 * See the xTimerChangePeriod() API function example usage scenario.
 */
#define xTimerDelete( xTimer, xTicksToWait ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_DELETE, 0U, NULL, ( xTicksToWait ) )

/**
 * BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );
 *
 * Timer functionality is provided by a timer service/daemon task.    Many of the
 * public FreeRTOS timer API functions send commands to the timer service task
 * through a queue called the timer command queue.    The timer command queue is
 * private to the kernel itself and is not directly accessible to application
 * code.    The length of the timer command queue is set by the
 * configTIMER_QUEUE_LENGTH configuration constant.
 *
 * xTimerReset() re-starts a timer that was previously created using the
 * xTimerCreate() API function.    If the timer had already been started and was
 * already in the active state, then xTimerReset() will cause the timer to
 * re-evaluate its expiry time so that it is relative to when xTimerReset() was
 * called.    If the timer was in the dormant state then xTimerReset() has
 * equivalent functionality to the xTimerStart() API function.
 *
 * Resetting a timer ensures the timer is in the active state.    If the timer
 * is not stopped, deleted, or reset in the mean time, the callback function
 * associated with the timer will get called 'n' ticks after xTimerReset() was
 * called, where 'n' is the timers defined period.
 *
 * It is valid to call xTimerReset() before the scheduler has been started, but
 * when this is done the timer will not actually start until the scheduler is
 * started, and the timers expiry time will be relative to when the scheduler is
 * started, not relative to when xTimerReset() was called.
 *
 * The configUSE_TIMERS configuration constant must be set to 1 for xTimerReset()
 * to be available.
 *
 * @param xTimer The handle of the timer being reset/started/restarted.
 *
 * @param xTicksToWait Specifies the time, in ticks, that the calling task should
 * be held in the Blocked state to wait for the reset command to be successfully
 * sent to the timer command queue, should the queue already be full when
 * xTimerReset() was called.    xTicksToWait is ignored if xTimerReset() is called
 * before the scheduler is started.
 *
 * @return pdFAIL will be returned if the reset command could not be sent to
 * the timer command queue even after xTicksToWait ticks had passed.    pdPASS will
 * be returned if the command was successfully sent to the timer command queue.
 * When the command is actually processed will depend on the priority of the
 * timer service/daemon task relative to other tasks in the system, although the
 * timers expiry time is relative to when xTimerStart() is actually called.    The
 * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
 * configuration constant.
 *
 * Example usage:
 * @verbatim
 * // When a key is pressed, an LCD back-light is switched on.    If 5 seconds pass
 * // without a key being pressed, then the LCD back-light is switched off.    In
 * // this case, the timer is a one-shot timer.
 *
 * TimerHandle_t xBacklightTimer = NULL;
 *
 * // The callback function assigned to the one-shot timer.    In this case the
 * // parameter is not used.
 * void vBacklightTimerCallback( TimerHandle_t pxTimer )
 * {
 *         // The timer expired, therefore 5 seconds must have passed since a key
 *         // was pressed.    Switch off the LCD back-light.
 *         vSetBacklightState( BACKLIGHT_OFF );
 * }
 *
 * // The key press event handler.
 * void vKeyPressEventHandler( char cKey )
 * {
 *         // Ensure the LCD back-light is on, then reset the timer that is
 *         // responsible for turning the back-light off after 5 seconds of
 *         // key inactivity.    Wait 10 ticks for the command to be successfully sent
 *         // if it cannot be sent immediately.
 *         vSetBacklightState( BACKLIGHT_ON );
 *         if( xTimerReset( xBacklightTimer, 100 ) != pdPASS )
 *         {
 *                 // The reset command was not executed successfully.    Take appropriate
 *                 // action here.
 *         }
 *
 *         // Perform the rest of the key processing here.
 * }
 *
 * void main( void )
 * {
 * int32_t x;
 *
 *         // Create then start the one-shot timer that is responsible for turning
 *         // the back-light off if no keys are pressed within a 5 second period.
 *         xBacklightTimer = xTimerCreate( "BacklightTimer",                     // Just a text name, not used by the kernel.
 *                                                                         ( 5000 / portTICK_PERIOD_MS), // The timer period in ticks.
 *                                                                         pdFALSE,                                        // The timer is a one-shot timer.
 *                                                                         0,                                                    // The id is not used by the callback so can take any value.
 *                                                                         vBacklightTimerCallback         // The callback function that switches the LCD back-light off.
 *                                                                     );
 *
 *         if( xBacklightTimer == NULL )
 *         {
 *                 // The timer was not created.
 *         }
 *         else
 *         {
 *                 // Start the timer.    No block time is specified, and even if one was
 *                 // it would be ignored because the scheduler has not yet been
 *                 // started.
 *                 if( xTimerStart( xBacklightTimer, 0 ) != pdPASS )
 *                 {
 *                         // The timer could not be set into the Active state.
 *                 }
 *         }
 *
 *         // ...
 *         // Create tasks here.
 *         // ...
 *
 *         // Starting the scheduler will start the timer running as it has already
 *         // been set into the active state.
 *         vTaskStartScheduler();
 *
 *         // Should not reach here.
 *         for( ;; );
 * }
 * @endverbatim
 */
#define xTimerReset( xTimer, xTicksToWait ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) )

/**
 * BaseType_t xTimerStartFromISR(     TimerHandle_t xTimer,
 *                                                                    BaseType_t *pxHigherPriorityTaskWoken );
 *
 * A version of xTimerStart() that can be called from an interrupt service
 * routine.
 *
 * @param xTimer The handle of the timer being started/restarted.
 *
 * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
 * of its time in the Blocked state, waiting for messages to arrive on the timer
 * command queue.    Calling xTimerStartFromISR() writes a message to the timer
 * command queue, so has the potential to transition the timer service/daemon
 * task out of the Blocked state.    If calling xTimerStartFromISR() causes the
 * timer service/daemon task to leave the Blocked state, and the timer service/
 * daemon task has a priority equal to or greater than the currently executing
 * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
 * get set to pdTRUE internally within the xTimerStartFromISR() function.    If
 * xTimerStartFromISR() sets this value to pdTRUE then a context switch should
 * be performed before the interrupt exits.
 *
 * @return pdFAIL will be returned if the start command could not be sent to
 * the timer command queue.    pdPASS will be returned if the command was
 * successfully sent to the timer command queue.    When the command is actually
 * processed will depend on the priority of the timer service/daemon task
 * relative to other tasks in the system, although the timers expiry time is
 * relative to when xTimerStartFromISR() is actually called.    The timer
 * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
 * configuration constant.
 *
 * Example usage:
 * @verbatim
 * // This scenario assumes xBacklightTimer has already been created.    When a
 * // key is pressed, an LCD back-light is switched on.    If 5 seconds pass
 * // without a key being pressed, then the LCD back-light is switched off.    In
 * // this case, the timer is a one-shot timer, and unlike the example given for
 * // the xTimerReset() function, the key press event handler is an interrupt
 * // service routine.
 *
 * // The callback function assigned to the one-shot timer.    In this case the
 * // parameter is not used.
 * void vBacklightTimerCallback( TimerHandle_t pxTimer )
 * {
 *         // The timer expired, therefore 5 seconds must have passed since a key
 *         // was pressed.    Switch off the LCD back-light.
 *         vSetBacklightState( BACKLIGHT_OFF );
 * }
 *
 * // The key press interrupt service routine.
 * void vKeyPressEventInterruptHandler( void )
 * {
 * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 *
 *         // Ensure the LCD back-light is on, then restart the timer that is
 *         // responsible for turning the back-light off after 5 seconds of
 *         // key inactivity.    This is an interrupt service routine so can only
 *         // call FreeRTOS API functions that end in "FromISR".
 *         vSetBacklightState( BACKLIGHT_ON );
 *
 *         // xTimerStartFromISR() or xTimerResetFromISR() could be called here
 *         // as both cause the timer to re-calculate its expiry time.
 *         // xHigherPriorityTaskWoken was initialised to pdFALSE when it was
 *         // declared (in this function).
 *         if( xTimerStartFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS )
 *         {
 *                 // The start command was not executed successfully.    Take appropriate
 *                 // action here.
 *         }
 *
 *         // Perform the rest of the key processing here.
 *
 *         // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
 *         // should be performed.    The syntax required to perform a context switch
 *         // from inside an ISR varies from port to port, and from compiler to
 *         // compiler.    Inspect the demos for the port you are using to find the
 *         // actual syntax required.
 *         if( xHigherPriorityTaskWoken != pdFALSE )
 *         {
 *                 // Call the interrupt safe yield function here (actual function
 *                 // depends on the FreeRTOS port being used).
 *         }
 * }
 * @endverbatim
 */
#define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )

/**
 * BaseType_t xTimerStopFromISR(        TimerHandle_t xTimer,
 *                                                                    BaseType_t *pxHigherPriorityTaskWoken );
 *
 * A version of xTimerStop() that can be called from an interrupt service
 * routine.
 *
 * @param xTimer The handle of the timer being stopped.
 *
 * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
 * of its time in the Blocked state, waiting for messages to arrive on the timer
 * command queue.    Calling xTimerStopFromISR() writes a message to the timer
 * command queue, so has the potential to transition the timer service/daemon
 * task out of the Blocked state.    If calling xTimerStopFromISR() causes the
 * timer service/daemon task to leave the Blocked state, and the timer service/
 * daemon task has a priority equal to or greater than the currently executing
 * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
 * get set to pdTRUE internally within the xTimerStopFromISR() function.    If
 * xTimerStopFromISR() sets this value to pdTRUE then a context switch should
 * be performed before the interrupt exits.
 *
 * @return pdFAIL will be returned if the stop command could not be sent to
 * the timer command queue.    pdPASS will be returned if the command was
 * successfully sent to the timer command queue.    When the command is actually
 * processed will depend on the priority of the timer service/daemon task
 * relative to other tasks in the system.    The timer service/daemon task
 * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
 *
 * Example usage:
 * @verbatim
 * // This scenario assumes xTimer has already been created and started.    When
 * // an interrupt occurs, the timer should be simply stopped.
 *
 * // The interrupt service routine that stops the timer.
 * void vAnExampleInterruptServiceRoutine( void )
 * {
 * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 *
 *         // The interrupt has occurred - simply stop the timer.
 *         // xHigherPriorityTaskWoken was set to pdFALSE where it was defined
 *         // (within this function).    As this is an interrupt service routine, only
 *         // FreeRTOS API functions that end in "FromISR" can be used.
 *         if( xTimerStopFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )
 *         {
 *                 // The stop command was not executed successfully.    Take appropriate
 *                 // action here.
 *         }
 *
 *         // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
 *         // should be performed.    The syntax required to perform a context switch
 *         // from inside an ISR varies from port to port, and from compiler to
 *         // compiler.    Inspect the demos for the port you are using to find the
 *         // actual syntax required.
 *         if( xHigherPriorityTaskWoken != pdFALSE )
 *         {
 *                 // Call the interrupt safe yield function here (actual function
 *                 // depends on the FreeRTOS port being used).
 *         }
 * }
 * @endverbatim
 */
#define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP_FROM_ISR, 0, ( pxHigherPriorityTaskWoken ), 0U )

/**
 * BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer,
 *                                                                             TickType_t xNewPeriod,
 *                                                                             BaseType_t *pxHigherPriorityTaskWoken );
 *
 * A version of xTimerChangePeriod() that can be called from an interrupt
 * service routine.
 *
 * @param xTimer The handle of the timer that is having its period changed.
 *
 * @param xNewPeriod The new period for xTimer. Timer periods are specified in
 * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a time
 * that has been specified in milliseconds.    For example, if the timer must
 * expire after 100 ticks, then xNewPeriod should be set to 100.    Alternatively,
 * if the timer must expire after 500ms, then xNewPeriod can be set to
 * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than
 * or equal to 1000.
 *
 * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
 * of its time in the Blocked state, waiting for messages to arrive on the timer
 * command queue.    Calling xTimerChangePeriodFromISR() writes a message to the
 * timer command queue, so has the potential to transition the timer service/
 * daemon task out of the Blocked state.    If calling xTimerChangePeriodFromISR()
 * causes the timer service/daemon task to leave the Blocked state, and the
 * timer service/daemon task has a priority equal to or greater than the
 * currently executing task (the task that was interrupted), then
 * *pxHigherPriorityTaskWoken will get set to pdTRUE internally within the
 * xTimerChangePeriodFromISR() function.    If xTimerChangePeriodFromISR() sets
 * this value to pdTRUE then a context switch should be performed before the
 * interrupt exits.
 *
 * @return pdFAIL will be returned if the command to change the timers period
 * could not be sent to the timer command queue.    pdPASS will be returned if the
 * command was successfully sent to the timer command queue.    When the command
 * is actually processed will depend on the priority of the timer service/daemon
 * task relative to other tasks in the system.    The timer service/daemon task
 * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
 *
 * Example usage:
 * @verbatim
 * // This scenario assumes xTimer has already been created and started.    When
 * // an interrupt occurs, the period of xTimer should be changed to 500ms.
 *
 * // The interrupt service routine that changes the period of xTimer.
 * void vAnExampleInterruptServiceRoutine( void )
 * {
 * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 *
 *         // The interrupt has occurred - change the period of xTimer to 500ms.
 *         // xHigherPriorityTaskWoken was set to pdFALSE where it was defined
 *         // (within this function).    As this is an interrupt service routine, only
 *         // FreeRTOS API functions that end in "FromISR" can be used.
 *         if( xTimerChangePeriodFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )
 *         {
 *                 // The command to change the timers period was not executed
 *                 // successfully.    Take appropriate action here.
 *         }
 *
 *         // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
 *         // should be performed.    The syntax required to perform a context switch
 *         // from inside an ISR varies from port to port, and from compiler to
 *         // compiler.    Inspect the demos for the port you are using to find the
 *         // actual syntax required.
 *         if( xHigherPriorityTaskWoken != pdFALSE )
 *         {
 *                 // Call the interrupt safe yield function here (actual function
 *                 // depends on the FreeRTOS port being used).
 *         }
 * }
 * @endverbatim
 */
#define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD_FROM_ISR, ( xNewPeriod ), ( pxHigherPriorityTaskWoken ), 0U )

/**
 * BaseType_t xTimerResetFromISR(     TimerHandle_t xTimer,
 *                                                                    BaseType_t *pxHigherPriorityTaskWoken );
 *
 * A version of xTimerReset() that can be called from an interrupt service
 * routine.
 *
 * @param xTimer The handle of the timer that is to be started, reset, or
 * restarted.
 *
 * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
 * of its time in the Blocked state, waiting for messages to arrive on the timer
 * command queue.    Calling xTimerResetFromISR() writes a message to the timer
 * command queue, so has the potential to transition the timer service/daemon
 * task out of the Blocked state.    If calling xTimerResetFromISR() causes the
 * timer service/daemon task to leave the Blocked state, and the timer service/
 * daemon task has a priority equal to or greater than the currently executing
 * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
 * get set to pdTRUE internally within the xTimerResetFromISR() function.    If
 * xTimerResetFromISR() sets this value to pdTRUE then a context switch should
 * be performed before the interrupt exits.
 *
 * @return pdFAIL will be returned if the reset command could not be sent to
 * the timer command queue.    pdPASS will be returned if the command was
 * successfully sent to the timer command queue.    When the command is actually
 * processed will depend on the priority of the timer service/daemon task
 * relative to other tasks in the system, although the timers expiry time is
 * relative to when xTimerResetFromISR() is actually called.    The timer service/daemon
 * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.
 *
 * Example usage:
 * @verbatim
 * // This scenario assumes xBacklightTimer has already been created.    When a
 * // key is pressed, an LCD back-light is switched on.    If 5 seconds pass
 * // without a key being pressed, then the LCD back-light is switched off.    In
 * // this case, the timer is a one-shot timer, and unlike the example given for
 * // the xTimerReset() function, the key press event handler is an interrupt
 * // service routine.
 *
 * // The callback function assigned to the one-shot timer.    In this case the
 * // parameter is not used.
 * void vBacklightTimerCallback( TimerHandle_t pxTimer )
 * {
 *         // The timer expired, therefore 5 seconds must have passed since a key
 *         // was pressed.    Switch off the LCD back-light.
 *         vSetBacklightState( BACKLIGHT_OFF );
 * }
 *
 * // The key press interrupt service routine.
 * void vKeyPressEventInterruptHandler( void )
 * {
 * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 *
 *         // Ensure the LCD back-light is on, then reset the timer that is
 *         // responsible for turning the back-light off after 5 seconds of
 *         // key inactivity.    This is an interrupt service routine so can only
 *         // call FreeRTOS API functions that end in "FromISR".
 *         vSetBacklightState( BACKLIGHT_ON );
 *
 *         // xTimerStartFromISR() or xTimerResetFromISR() could be called here
 *         // as both cause the timer to re-calculate its expiry time.
 *         // xHigherPriorityTaskWoken was initialised to pdFALSE when it was
 *         // declared (in this function).
 *         if( xTimerResetFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS )
 *         {
 *                 // The reset command was not executed successfully.    Take appropriate
 *                 // action here.
 *         }
 *
 *         // Perform the rest of the key processing here.
 *
 *         // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
 *         // should be performed.    The syntax required to perform a context switch
 *         // from inside an ISR varies from port to port, and from compiler to
 *         // compiler.    Inspect the demos for the port you are using to find the
 *         // actual syntax required.
 *         if( xHigherPriorityTaskWoken != pdFALSE )
 *         {
 *                 // Call the interrupt safe yield function here (actual function
 *                 // depends on the FreeRTOS port being used).
 *         }
 * }
 * @endverbatim
 */
#define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) \
        xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )


/**
 * BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,
 *                                                                                    void *pvParameter1,
 *                                                                                    uint32_t ulParameter2,
 *                                                                                    BaseType_t *pxHigherPriorityTaskWoken );
 *
 *
 * Used from application interrupt service routines to defer the execution of a
 * function to the RTOS daemon task (the timer service task, hence this function
 * is implemented in timers.c and is prefixed with 'Timer').
 *
 * Ideally an interrupt service routine (ISR) is kept as short as possible, but
 * sometimes an ISR either has a lot of processing to do, or needs to perform
 * processing that is not deterministic.    In these cases
 * xTimerPendFunctionCallFromISR() can be used to defer processing of a function
 * to the RTOS daemon task.
 *
 * A mechanism is provided that allows the interrupt to return directly to the
 * task that will subsequently execute the pended callback function.    This
 * allows the callback function to execute contiguously in time with the
 * interrupt - just as if the callback had executed in the interrupt itself.
 *
 * @param xFunctionToPend The function to execute from the timer service/
 * daemon task.    The function must conform to the PendedFunction_t
 * prototype.
 *
 * @param pvParameter1 The value of the callback function's first parameter.
 * The parameter has a void * type to allow it to be used to pass any type.
 * For example, unsigned longs can be cast to a void *, or the void * can be
 * used to point to a structure.
 *
 * @param ulParameter2 The value of the callback function's second parameter.
 *
 * @param pxHigherPriorityTaskWoken As mentioned above, calling this function
 * will result in a message being sent to the timer daemon task.    If the
 * priority of the timer daemon task (which is set using
 * configTIMER_TASK_PRIORITY in FreeRTOSConfig.h) is higher than the priority of
 * the currently running task (the task the interrupt interrupted) then
 * *pxHigherPriorityTaskWoken will be set to pdTRUE within
 * xTimerPendFunctionCallFromISR(), indicating that a context switch should be
 * requested before the interrupt exits.    For that reason
 * *pxHigherPriorityTaskWoken must be initialised to pdFALSE.    See the
 * example code below.
 *
 * @return pdPASS is returned if the message was successfully sent to the
 * timer daemon task, otherwise pdFALSE is returned.
 *
 * Example usage:
 * @verbatim
 *
 *    // The callback function that will execute in the context of the daemon task.
 *    // Note callback functions must all use this same prototype.
 *    void vProcessInterface( void *pvParameter1, uint32_t ulParameter2 )
 *    {
 *            BaseType_t xInterfaceToService;
 *
 *            // The interface that requires servicing is passed in the second
 *            // parameter.    The first parameter is not used in this case.
 *            xInterfaceToService = ( BaseType_t ) ulParameter2;
 *
 *            // ...Perform the processing here...
 *    }
 *
 *    // An ISR that receives data packets from multiple interfaces
 *    void vAnISR( void )
 *    {
 *            BaseType_t xInterfaceToService, xHigherPriorityTaskWoken;
 *
 *            // Query the hardware to determine which interface needs processing.
 *            xInterfaceToService = prvCheckInterfaces();
 *
 *            // The actual processing is to be deferred to a task.    Request the
 *            // vProcessInterface() callback function is executed, passing in the
 *            // number of the interface that needs processing.    The interface to
 *            // service is passed in the second parameter.    The first parameter is
 *            // not used in this case.
 *            xHigherPriorityTaskWoken = pdFALSE;
 *            xTimerPendFunctionCallFromISR( vProcessInterface, NULL, ( uint32_t ) xInterfaceToService, &xHigherPriorityTaskWoken );
 *
 *            // If xHigherPriorityTaskWoken is now set to pdTRUE then a context
 *            // switch should be requested.    The macro used is port specific and will
 *            // be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() - refer to
 *            // the documentation page for the port being used.
 *            portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
 *
 *    }
 * @endverbatim
 */
BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,
                                                                                    void * pvParameter1,
                                                                                    uint32_t ulParameter2,
                                                                                    BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;

/**
 * BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,
 *                                                                        void *pvParameter1,
 *                                                                        uint32_t ulParameter2,
 *                                                                        TickType_t xTicksToWait );
 *
 *
 * Used to defer the execution of a function to the RTOS daemon task (the timer
 * service task, hence this function is implemented in timers.c and is prefixed
 * with 'Timer').
 *
 * @param xFunctionToPend The function to execute from the timer service/
 * daemon task.    The function must conform to the PendedFunction_t
 * prototype.
 *
 * @param pvParameter1 The value of the callback function's first parameter.
 * The parameter has a void * type to allow it to be used to pass any type.
 * For example, unsigned longs can be cast to a void *, or the void * can be
 * used to point to a structure.
 *
 * @param ulParameter2 The value of the callback function's second parameter.
 *
 * @param xTicksToWait Calling this function will result in a message being
 * sent to the timer daemon task on a queue.    xTicksToWait is the amount of
 * time the calling task should remain in the Blocked state (so not using any
 * processing time) for space to become available on the timer queue if the
 * queue is found to be full.
 *
 * @return pdPASS is returned if the message was successfully sent to the
 * timer daemon task, otherwise pdFALSE is returned.
 *
 */
BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,
                                                                     void * pvParameter1,
                                                                     uint32_t ulParameter2,
                                                                     TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

/**
 * const char * const pcTimerGetName( TimerHandle_t xTimer );
 *
 * Returns the name that was assigned to a timer when the timer was created.
 *
 * @param xTimer The handle of the timer being queried.
 *
 * @return The name assigned to the timer specified by the xTimer parameter.
 */
const char * pcTimerGetName( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

/**
 * void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload );
 *
 * Updates a timer to be either an auto-reload timer, in which case the timer
 * automatically resets itself each time it expires, or a one-shot timer, in
 * which case the timer will only expire once unless it is manually restarted.
 *
 * @param xTimer The handle of the timer being updated.
 *
 * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
 * expire repeatedly with a frequency set by the timer's period (see the
 * xTimerPeriodInTicks parameter of the xTimerCreate() API function).    If
 * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
 * enter the dormant state after it expires.
 */
void vTimerSetReloadMode( TimerHandle_t xTimer,
                                                    const UBaseType_t uxAutoReload ) PRIVILEGED_FUNCTION;

/**
 * UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer );
 *
 * Queries a timer to determine if it is an auto-reload timer, in which case the timer
 * automatically resets itself each time it expires, or a one-shot timer, in
 * which case the timer will only expire once unless it is manually restarted.
 *
 * @param xTimer The handle of the timer being queried.
 *
 * @return If the timer is an auto-reload timer then pdTRUE is returned, otherwise
 * pdFALSE is returned.
 */
UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

/**
 * TickType_t xTimerGetPeriod( TimerHandle_t xTimer );
 *
 * Returns the period of a timer.
 *
 * @param xTimer The handle of the timer being queried.
 *
 * @return The period of the timer in ticks.
 */
TickType_t xTimerGetPeriod( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

/**
 * TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer );
 *
 * Returns the time in ticks at which the timer will expire.    If this is less
 * than the current tick count then the expiry time has overflowed from the
 * current time.
 *
 * @param xTimer The handle of the timer being queried.
 *
 * @return If the timer is running then the time in ticks at which the timer
 * will next expire is returned.    If the timer is not running then the return
 * value is undefined.
 */
TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

/*
 * Functions beyond this part are not part of the public API and are intended
 * for use by the kernel only.
 */
BaseType_t xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION;
BaseType_t xTimerGenericCommand( TimerHandle_t xTimer,
                                                                 const BaseType_t xCommandID,
                                                                 const TickType_t xOptionalValue,
                                                                 BaseType_t * const pxHigherPriorityTaskWoken,
                                                                 const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

#if ( configUSE_TRACE_FACILITY == 1 )
        void vTimerSetTimerNumber( TimerHandle_t xTimer,
                                                             UBaseType_t uxTimerNumber ) PRIVILEGED_FUNCTION;
        UBaseType_t uxTimerGetTimerNumber( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
#endif

#if ( configSUPPORT_STATIC_ALLOCATION == 1 )

/**
 * task.h
 * @code{c}
 * void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer, StackType_t ** ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize )
 * @endcode
 *
 * This function is used to provide a statically allocated block of memory to FreeRTOS to hold the Timer Task TCB.    This function is required when
 * configSUPPORT_STATIC_ALLOCATION is set.    For more information see this URI: https://www.FreeRTOS.org/a00110.html#configSUPPORT_STATIC_ALLOCATION
 *
 * @param ppxTimerTaskTCBBuffer     A handle to a statically allocated TCB buffer
 * @param ppxTimerTaskStackBuffer A handle to a statically allocated Stack buffer for thie idle task
 * @param pulTimerTaskStackSize     A pointer to the number of elements that will fit in the allocated stack buffer
 */
        void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
                                                                                 StackType_t ** ppxTimerTaskStackBuffer,
                                                                                 uint32_t * pulTimerTaskStackSize );

#endif

/* *INDENT-OFF* */
#ifdef __cplusplus
        }
#endif
/* *INDENT-ON* */
#endif /* TIMERS_H */
